// 添加日志功能
const logger = {
    async shouldLog() {
        try {
            const { enableLogging = true } = await chrome.storage.sync.get('enableLogging');
            return enableLogging;
        } catch {
            return false; // 发生错误时默认不输出日志
        }
    },
    async debug(message, ...args) {
        if (await this.shouldLog()) {
            console.log(`[Form Persistence] ${message}`, ...args);
        }
    },
    async info(message, ...args) {
        if (await this.shouldLog()) {
            console.info(`[Form Persistence] ${message}`, ...args);
        }
    },
    async warn(message, ...args) {
        if (await this.shouldLog()) {
            console.warn(`[Form Persistence] ${message}`, ...args);
        }
    },
    async error(message, ...args) {
        if (await this.shouldLog()) {
            console.error(`[Form Persistence] ${message}`, ...args);
        }
    }
};

// 移除 compression 对象的具体实现，保留接口以保持兼容性
const compression = {
    // 直接返回原始数据，不进行压缩
    compress: async function(data) {
        return data;
    },

    // 直接返回原始数据，不进行解压缩
    decompress: async function(data) {
        return data;
    }
};

// 添加数据验证工具函数
const dataValidator = {
    // 检查字段值是否有效
    isValidValue(value) {
        if (value === null || value === undefined) return false;
        if (typeof value === 'string' && value.trim() === '') return false;
        if (typeof value === 'boolean') return true;
        return true;
    },

    // 检查字段名称是否有效
    isValidFieldName(name) {
        if (!name) return false;
        // 排除常见的自动生成字段
        const invalidNames = ['_', '__', 'undefined', 'null', 'NaN'];
        if (invalidNames.includes(name)) return false;
        // 检查字段名长度
        if (name.length < 1 || name.length > 100) return false;
        return true;
    },

    // 检查数据大小是否在合理范围内
    isValidDataSize(data) {
        const MAX_SIZE = 1024 * 1024; // 1MB
        try {
            const size = new Blob([JSON.stringify(data)]).size;
            return size <= MAX_SIZE;
        } catch (error) {
            logger.error('检查数据大小时出错:', error);
            return false;
        }
    },

    // 检查表单是否包含足够的有效数据
    hasValidContent(formData) {
        if (!formData || typeof formData !== 'object') return false;
        
        // 至少需要一个有效字段
        const validFields = Object.values(formData).filter(value => this.isValidValue(value));
        if (validFields.length === 0) return false;

        // 检查有效数据的比例
        const totalFields = Object.keys(formData).length;
        const validRatio = validFields.length / totalFields;
        return validRatio >= 0.1; // 至少10%的字段需要有效
    }
};

// 添加保存控制标志
let allowSaving = true;

// 监听消息
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    if (message.action === 'stopSaving') {
        logger.info('收到停止保存数据的指令');
        allowSaving = false;
        sendResponse({ success: true });
    } else if (message.action === 'checkStatus') {
        logger.info('收到状态检查指令');
        // 重新检查当前页面状态
        shouldRunOnCurrentPage().then(shouldRun => {
            allowSaving = shouldRun;
            logger.info('页面状态更新:', { shouldRun });
            sendResponse({ success: true, shouldRun });
        });
        return true; // 保持消息通道开放以进行异步响应
    } else if (message.action === 'reinitialize') {
        logger.info('收到重新初始化指令');
        // 重新初始化扩展功能
        initializeExtension();
        sendResponse({ success: true });
    } else if (message.action === 'updateLanguage') {
        logger.info('收到语言更新指令:', message.language);
        // 重新加载所有国际化文本
        updateI18nText();
        sendResponse({ success: true });
    }
    return true; // 保持消息通道开放
});

// 检查当前页面是否匹配配置的 URL 模式
async function shouldRunOnCurrentPage() {
    const currentUrl = window.location.href;
    // 使用数组形式获取storage数据
    const { enabledUrls = [], disabledUrls = [] } = await chrome.storage.sync.get(['enabledUrls', 'disabledUrls']);
    
    logger.debug('从存储中获取的数据:', { 
        currentUrl,
        enabledUrls: JSON.stringify(enabledUrls), 
        disabledUrls: JSON.stringify(disabledUrls)
    });

    // 首先检查是否在禁用列表中
    const isDisabled = disabledUrls.some(pattern => {
        if (!pattern || !currentUrl) return false;
        return currentUrl.includes(pattern);
    });

    // 如果在禁用列表中，直接返回 false
    if (isDisabled) {
        logger.info('当前页面已被禁用');
        return false;
    }
    
    // 检查是否在启用列表中
    return enabledUrls.some(pattern => {
        if (!pattern || !currentUrl) return false;
        const isMatch = currentUrl.includes(pattern);
        logger.debug('URL模式匹配结果:', { pattern, isMatch });
        return isMatch;
    });
}

// 检查当前 URL 是否被允许
async function checkUrlPermission() {
    try {
        const response = await chrome.runtime.sendMessage({
            action: 'checkPermission',
            url: window.location.href
        });
        return response.allowed;
    } catch (error) {
        console.error('检查 URL 权限时出错:', error);
        return false;
    }
}

// 监听页面 DOM 变化
function observeDOMChanges() {
    const observer = new MutationObserver((mutations) => {
        mutations.forEach(mutation => {
            // 检查新增的节点中是否有表单
            mutation.addedNodes.forEach(node => {
                if (node.nodeName === 'FORM') {
                    logger.info('检测到新的表单:', {
                        formId: node.id || '未命名表单'
                    });
                    setupFormListeners(node);
                } else if (node.querySelectorAll) {
                    // 检查新增节点的子节点中是否有表单
                    const forms = node.querySelectorAll('form');
                    forms.forEach(form => {
                        logger.info('检测到新的表单:', {
                            formId: form.id || '未命名表单'
                        });
                        setupFormListeners(form);
                    });
                }
            });
        });
    });

    // 监视整个文档的变化，包括子树
    observer.observe(document.documentElement, {
        childList: true,
        subtree: true
    });

    return observer;
}

// 监听表单变化
function setupFormListeners(form) {
    // 避免重复添加监听器
    if (form.dataset.hasFormPersistenceListeners) {
        return;
    }

    const inputs = form.querySelectorAll('input, textarea, select');
    logger.debug('设置表单监听器:', { 
        formId: form.id || '未命名表单',
        inputCount: inputs.length 
    });

    // 监听表单内新增的输入元素
    const inputObserver = new MutationObserver((mutations) => {
        mutations.forEach(mutation => {
            mutation.addedNodes.forEach(node => {
                if (node.tagName === 'INPUT' || node.tagName === 'TEXTAREA' || node.tagName === 'SELECT') {
                    setupInputListener(node);
                }
            });
        });
    });

    inputObserver.observe(form, {
        childList: true,
        subtree: true
    });

    // 为每个输入元素添加监听器
    inputs.forEach(input => setupInputListener(input));

    // 标记该表单已设置监听器
    form.dataset.hasFormPersistenceListeners = 'true';
}

// 为单个输入元素设置监听器
function setupInputListener(input) {
    if (input.dataset.hasFormPersistenceListeners) {
        return;
    }

    const handleChange = (event) => {
        // 使用 setTimeout 确保在原有事件处理完成后再保存数据
        setTimeout(() => {
            logger.debug('表单输入变化:', {
                inputType: input.type,
                inputId: input.id || input.name || '未命名输入框'
            });
            saveFormData();
        }, 0);
    };

    ['change', 'input'].forEach(eventType => {
        // 使用事件捕获确保我们的监听器最后执行
        input.addEventListener(eventType, handleChange, { 
            capture: false,
            passive: true
        });
    });

    input.dataset.hasFormPersistenceListeners = 'true';
}

// 检查元素是否可见
function isElementVisible(element) {
    if (!element) return false;
    
    const style = window.getComputedStyle(element);
    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
        return false;
    }

    const rect = element.getBoundingClientRect();
    if (rect.width === 0 || rect.height === 0) {
        return false;
    }

    // 检查所有父元素的可见性
    let currentElement = element;
    while (currentElement && currentElement !== document.body) {
        const parentStyle = window.getComputedStyle(currentElement);
        if (parentStyle.display === 'none' || 
            parentStyle.visibility === 'hidden' || 
            parentStyle.opacity === '0') {
            return false;
        }
        currentElement = currentElement.parentElement;
    }

    // 检查元素是否在视口内或是否被其他元素遮挡
    const centerX = rect.left + rect.width / 2;
    const centerY = rect.top + rect.height / 2;
    if (centerX < 0 || centerY < 0 || centerX > window.innerWidth || centerY > window.innerHeight) {
        return false;
    }

    const elementAtPoint = document.elementFromPoint(centerX, centerY);
    return element === elementAtPoint || element.contains(elementAtPoint);
}

// 本地化消息管理系统
const i18nMessageCache = {
    zh_CN: null,
    en: null,
    // 添加缓存时间戳
    timestamp: null,
    // 缓存有效期（24小时）
    maxAge: 24 * 60 * 60 * 1000
};

// 从存储中加载缓存的消息
async function loadCachedMessages() {
    try {
        const result = await chrome.storage.local.get('i18nMessageCache');
        if (result.i18nMessageCache) {
            // 检查缓存是否过期
            const now = Date.now();
            if (result.i18nMessageCache.timestamp && 
                (now - result.i18nMessageCache.timestamp) < i18nMessageCache.maxAge) {
                Object.assign(i18nMessageCache, result.i18nMessageCache);
                logger.debug('已从缓存加载语言消息');
            } else {
                logger.debug('缓存已过期，需要重新加载');
                // 清除过期的缓存
                await chrome.storage.local.remove('i18nMessageCache');
            }
        }
    } catch (error) {
        logger.error('加载缓存的语言消息失败:', error);
    }
}

// 将消息保存到缓存
async function saveCachedMessages() {
    try {
        // 更新时间戳
        i18nMessageCache.timestamp = Date.now();
        await chrome.storage.local.set({ i18nMessageCache });
        logger.debug('已保存语言消息到缓存');
    } catch (error) {
        logger.error('保存语言消息到缓存失败:', error);
    }
}

// 加载指定语言的消息
async function loadMessages(locale) {
    // 先从预加载缓存中获取
    const cacheKey = `i18n_${locale}`;
    try {
        const cache = await chrome.storage.local.get(cacheKey);
        if (cache[cacheKey] && cache[cacheKey].messages) {
            logger.debug('从预加载缓存加载语言消息:', locale);
            return cache[cacheKey].messages;
        }
    } catch (error) {
        logger.error('加载缓存的语言消息失败:', error);
    }

    // 如果缓存中没有，尝试从文件加载
    try {
        const response = await fetch(chrome.runtime.getURL(`_locales/${locale}/messages.json`));
        const messages = await response.json();
        
        // 保存到缓存
        await chrome.storage.local.set({
            [cacheKey]: {
                messages,
                timestamp: Date.now()
            }
        });
        
        return messages;
    } catch (error) {
        logger.error('加载语言消息失败:', error);
        // 如果加载失败且不是默认语言，尝试回退到默认语言
        if (locale !== 'zh_CN') {
            logger.warn(`加载语言 ${locale} 失败，回退到默认语言`);
            return loadMessages('zh_CN');
        }
        return null;
    }
}

// 获取指定语言的消息
async function getMessageFromLocale(key, locale, substitutions = null) {
    const messages = await loadMessages(locale);
    if (!messages || !messages[key]) {
        return key;
    }

    let message = messages[key].message;

    // 处理替换参数
    if (substitutions && messages[key].placeholders) {
        Object.entries(messages[key].placeholders).forEach(([placeholder, config]) => {
            const index = parseInt(config.content.replace('$', '')) - 1;
            if (substitutions[index]) {
                message = message.replace(`$${placeholder.toUpperCase()}$`, substitutions[index]);
            }
        });
    }

    return message;
}

// 更新获取消息的函数
async function getMessage(key, substitutions = null) {
    const { language = 'zh_CN' } = await chrome.storage.sync.get('language');
    return await getMessageFromLocale(key, language, substitutions);
}

// 显示通知消息
async function createNotification(messageKey, type = 'info') {
    // 获取国际化的消息文本
    const text = await getMessage(messageKey);
    
    const notification = document.createElement('div');
    notification.className = `form-persistence-notification ${type}`;
    notification.textContent = text;
    
    document.body.appendChild(notification);
    
    setTimeout(() => {
        notification.classList.add('fade-out');
        setTimeout(() => notification.remove(), 300);
    }, 3000);
}

// 数据集管理系统
const datasetManager = {
    // 保存数据集
    async saveDataset(name, data) {
        try {
            const url = window.location.href;
            const { datasets = {} } = await chrome.storage.local.get('datasets');
            
            if (!datasets[url]) {
                datasets[url] = {};
            }
            
            datasets[url][name] = {
                data: data,
                timestamp: new Date().toISOString(),
                url: url
            };
            
            await chrome.storage.local.set({ datasets });
            await createNotification('datasetSaved');
            return true;
        } catch (error) {
            logger.error('保存数据集失败:', error);
            return false;
        }
    },

    // 加载数据集
    async loadDataset(name) {
        try {
            const url = window.location.href;
            const { datasets = {} } = await chrome.storage.local.get('datasets');
            
            if (!datasets[url] || !datasets[url][name]) {
                return null;
            }
            
            return datasets[url][name].data;
        } catch (error) {
            logger.error('加载数据集失败:', error);
            return null;
        }
    },

    // 获取当前页面的所有数据集
    async getPageDatasets() {
        try {
            const url = window.location.href;
            const { datasets = {} } = await chrome.storage.local.get('datasets');
            
            return datasets[url] || {};
        } catch (error) {
            logger.error('获取数据集列表失败:', error);
            return {};
        }
    },

    // 删除数据集
    async deleteDataset(name) {
        try {
            const url = window.location.href;
            const { datasets = {} } = await chrome.storage.local.get('datasets');
            
            if (datasets[url] && datasets[url][name]) {
                delete datasets[url][name];
                if (Object.keys(datasets[url]).length === 0) {
                    delete datasets[url];
                }
                await chrome.storage.local.set({ datasets });
                await createNotification('datasetDeleted');
                return true;
            }
            return false;
        } catch (error) {
            logger.error('删除数据集失败:', error);
            return false;
        }
    }
};

// 保存表单数据
async function saveFormData() {
    if (!allowSaving) {
        createNotification('savingDisabled', 'warning');
        return;
    }

    try {
        const formData = {};
        let hasValidData = false;
        
        // 1. 首先处理form标签内的元素
        const forms = document.querySelectorAll('form');
        forms.forEach((form, formIndex) => {
            const formFields = {};
            const formStats = { validFieldCount: 0 };
            
            const inputs = Array.from(form.getElementsByTagName('input'))
                .concat(Array.from(form.getElementsByTagName('textarea')))
                .concat(Array.from(form.getElementsByTagName('select')));
            
            inputs.forEach(input => processInput(input, formFields, formStats));

            // 验证表单数据的有效性
            if (formStats.validFieldCount > 0 && dataValidator.hasValidContent(formFields)) {
                formData[`form_${formIndex}`] = formFields;
                hasValidData = true;
            } else {
                logger.debug('表单数据验证失败，跳过保存:', formIndex);
            }
        });

        // 2. 处理非form标签内的表单元素
        const standaloneInputs = Array.from(document.getElementsByTagName('input'))
            .concat(Array.from(document.getElementsByTagName('textarea')))
            .concat(Array.from(document.getElementsByTagName('select')))
            .filter(input => !input.closest('form')); // 过滤出不在form内的元素

        if (standaloneInputs.length > 0) {
            const standaloneFields = {};
            const standaloneStats = { validFieldCount: 0 };

            standaloneInputs.forEach(input => {
                processInput(input, standaloneFields, standaloneStats);
            });

            // 验证独立表单数据的有效性
            if (standaloneStats.validFieldCount > 0 && dataValidator.hasValidContent(standaloneFields)) {
                formData['standalone_inputs'] = standaloneFields;
                hasValidData = true;
            }
        }

        // 验证整体数据大小
        if (!dataValidator.isValidDataSize(formData)) {
        logger.warn('表单数据超出大小限制，跳过保存');
            createNotification('dataTooLarge', 'warning');
            return;
        }

        // 只在有有效数据时保存
        if (hasValidData && Object.keys(formData).length > 0) {
            const currentUrl = window.location.href;
            try {
                await chrome.storage.local.set({
                    [currentUrl]: {
                        data: formData,
                        lastModified: Date.now()
                    }
                });
                createNotification(getMessage('dataSaved', [Object.keys(formData).length]), 'success');
                logger.debug('表单数据已保存');
            } catch (error) {
                createNotification('savingError', 'error');
                logger.error('保存表单数据失败:', error);
            }
        } else {
            logger.info('没有找到有效的表单数据，跳过保存');
        }
        
    } catch (error) {
        logger.error('保存数据时出错:', error);
        createNotification('savingError', 'error');
    }
}

// 处理单个输入元素
function processInput(input, fields, stats) {
    // 跳过隐藏字段和安全相关字段
    if (input.type === 'hidden' || 
        input.name?.toLowerCase().includes('token') || 
        input.name?.toLowerCase().includes('security') ||
        input.name?.toLowerCase().includes('csrf') ||
        input.name?.toLowerCase().includes('xsrf') ||
        input.id?.toLowerCase().includes('token') ||
        input.id?.toLowerCase().includes('security') ||
        input.id?.toLowerCase().includes('csrf') ||
        input.id?.toLowerCase().includes('xsrf')) {
        logger.debug('跳过安全相关字段:', input.name || input.id);
        return;
    }

    // 获取字段标识符
    let identifier;
    
    if (input.id || input.name) {
        identifier = input.id || input.name;
    } else {
               // 获取元素类型，如果没有type属性则使用tagName
               const elementType = input.type || input.tagName.toLowerCase();
        
               // 获取表单上下文
               const form = input.closest('form');
               const formIndex = form ? Array.from(document.forms).indexOf(form) : 'standalone';
               
               // 获取同类型元素的序号
               let typeIndex = 0;
               if (form) {
                   // 在表单内查找同类型元素
                   const sameTypeElements = Array.from(form.querySelectorAll(`input[type="${elementType}"], ${elementType}`));
                   typeIndex = sameTypeElements.indexOf(input);
               } else {
                   // 在整个文档中查找不在表单内的同类型元素
                   const sameTypeElements = Array.from(document.querySelectorAll(`input[type="${elementType}"], ${elementType}`))
                       .filter(el => !el.closest('form'));
                   typeIndex = sameTypeElements.indexOf(input);
               }
               
               // 生成标识符: 类型_表单索引_序号
               identifier = `${elementType}_form${formIndex}_${typeIndex}`;
               
               // 如果元素有label，添加label文本作为额外标识
               const label = input.labels?.[0]?.textContent.trim();
               if (label) {
                   const labelHash = label.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8);
                   identifier += `_${labelHash}`;
               }
               
               // 如果有placeholder，也添加进标识符
               if (input.placeholder) {
                   const placeholderHash = input.placeholder.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8);
                   identifier += `_${placeholderHash}`;
               }
               
               logger.debug('生成的标识符:', { 
                   identifier, 
                   elementType, 
                   formIndex, 
                   typeIndex 
               });
    }
    
    // 验证字段名称是否有效
    if (!dataValidator.isValidFieldName(identifier)) {
        logger.debug('跳过无效的字段名称:', identifier);
        return;
    }

    // 获取字段值
    let fieldValue;
    if (input.type === 'checkbox' || input.type === 'radio') {
        fieldValue = input.checked;
    } else {
        fieldValue = input.value.trim();
    }

    // 验证字段值是否有效
    if (!dataValidator.isValidValue(fieldValue)) {
        logger.debug('跳过无效的字段值:', { identifier, fieldValue });
        return;
    }

    // 保存字段值，并增加有效字段计数
    fields[identifier] = fieldValue;
    if (stats && typeof stats === 'object') {
        stats.validFieldCount = (stats.validFieldCount || 0) + 1;
    }
}

// 恢复表单数据
async function restoreFormData(retryCount = 0, maxRetries = 5) {
    try {
        const currentUrl = window.location.href;
        const result = await chrome.storage.local.get(currentUrl);
        const savedData = result[currentUrl];

        if (!savedData || !savedData.data) {
            return;
        }

        let restoredCount = 0;
        // 检查并解压缩数据
        const formData = savedData.isCompressed ? 
            await compression.decompress(savedData.data) : 
            savedData.data;

        // 检查缓存的时间戳
        const pageLoadTime = window.performance.timing.navigationStart + window.performance.now();
        const lastModified = savedData.lastModified || 0;

        // 如果页面加载时间晚于数据最后修改时间，则不恢复数据
        if (pageLoadTime < lastModified) {
            logger.info('检测到更新的数据编辑，跳过数据恢复');
            return;
        }

        logger.info('找到保存的表单数据:', savedData);
        
        // 统计恢复情况
        let totalFields = 0;
        let restoredFields = 0;
        let missingElements = [];
        let restoredElements = new Set();

        // 用于根据标识符查找元素的辅助函数
        const findElementByIdentifier = (identifier, formElement = null) => {
            // 1. 首先尝试通过 id 或 name 直接查找
            let element = formElement ? 
                formElement.querySelector(`[id="${identifier}"], [name="${identifier}"]`) :
                document.querySelector(`[id="${identifier}"], [name="${identifier}"]`);
            
            if (element) return element;

            // 2. 如果是生成的标识符，解析其组成部分
            const match = identifier.match(/^(\w+)_form(\d+|standalone)_(\d+)(?:_.*)?$/);
            if (!match) return null;

            const [, elementType, formIndex, typeIndex] = match;
            
            // 3. 根据解析出的信息查找元素
            if (formIndex === 'standalone') {
                // 查找不在表单内的元素
                const standaloneElements = Array.from(document.querySelectorAll(`input[type="${elementType}"], ${elementType}`))
                    .filter(el => !el.closest('form'));
                return standaloneElements[parseInt(typeIndex)] || null;
            } else {
                // 查找表单内的元素
                const form = document.forms[parseInt(formIndex)];
                if (!form) return null;

                const elements = Array.from(form.querySelectorAll(`input[type="${elementType}"], ${elementType}`));
                return elements[parseInt(typeIndex)] || null;
            }
        };

        // 处理表单数据
        for (const [formKey, fields] of Object.entries(formData)) {
            // 确定处理上下文（表单或文档）
            let context = null;
            if (formKey !== 'standalone_inputs') {
                const formIndex = parseInt(formKey.replace('form_', ''));
                context = document.forms[formIndex];
                if (!context) {
                    logger.debug(`表单 ${formIndex} 未找到，可能是动态加载的表单`);
                    continue;
                }
            }

            // 处理字段
            for (const [fieldName, value] of Object.entries(fields)) {
                totalFields++;
                
                // 查找对应的表单元素
                const input = findElementByIdentifier(fieldName, context);
                
                if (!input) {
                    missingElements.push(fieldName);
                    continue;
                }

                // 检查元素是否已经被恢复过
                if (restoredElements.has(input)) {
                    continue;
                }

                try {
                    // 恢复值
                    if (input.type === 'checkbox' || input.type === 'radio') {
                        input.checked = value;
                    } else {
                        input.value = value;
                    }
                    
                    // 触发 change 事件
                    input.dispatchEvent(new Event('change', { bubbles: true }));
                    input.dispatchEvent(new Event('input', { bubbles: true }));
                    
                    restoredFields++;
                    restoredElements.add(input);
                    
                    // 为恢复的元素添加监听器
                    if (context) {
                        setupFormListeners(context);
                    } else {
                        setupInputListener(input);
                    }
                } catch (error) {
                    logger.warn(`恢复字段 ${fieldName} 时出错:`, error);
                    missingElements.push(fieldName);
                }
            }
        }

        // 如果有未恢复的字段且未超过最大重试次数，则延迟后重试
        if (missingElements.length > 0 && retryCount < maxRetries) {
            logger.debug(`${missingElements.length} 个字段未找到，将在 1 秒后重试`);
            setTimeout(() => restoreFormData(retryCount + 1, maxRetries), 1000);
            return;
        }

        // 显示恢复状态提示
        if (missingElements.length > 0) {
            const message = `已恢复 ${restoredFields}/${totalFields} 个字段。${missingElements.length} 个字段未找到对应元素`;
            createNotification(message, 'warning');
            logger.warn('部分字段未找到:', missingElements);
        } else if (restoredFields > 0) {
            createNotification(getMessage('dataRestored', [restoredFields]), 'success');
        }
    } catch (error) {
        logger.error('恢复表单数据时出错:', error);
        createNotification('restoringError', 'error');
        if (retryCount < maxRetries) {
            setTimeout(() => restoreFormData(retryCount + 1, maxRetries), 1000);
        }
    }
}

// 初始化扩展功能
async function initializeExtension() {
    logger.info('初始化表单持久化扩展...');
    
    // 加载缓存的语言消息
    await loadCachedMessages();
    
    const shouldRun = await shouldRunOnCurrentPage();
    console.log('shouldRun:', shouldRun);
    if (!shouldRun) {
        logger.info('当前页面未启用表单持久化');
        return;
    }

    logger.info('当前页面已启用表单持久化');

    // 启动 DOM 观察器
    const observer = observeDOMChanges();

    // 使用 MutationObserver 监听表单变化
    const formObserver = new MutationObserver((mutations) => {
        let hasNewForm = false;
        mutations.forEach(mutation => {
            mutation.addedNodes.forEach(node => {
                if (node.nodeName === 'FORM' || 
                    (node.querySelectorAll && node.querySelectorAll('form').length > 0)) {
                    hasNewForm = true;
                }
            });
        });

        // 如果检测到新的表单，尝试恢复数据
        if (hasNewForm) {
            logger.debug('检测到新的表单，尝试恢复数据');
            setTimeout(() => restoreFormData(0, 5), 500);
        }
    });

    // 监听文档变化
    formObserver.observe(document.body, {
        childList: true,
        subtree: true
    });

    // 根据文档加载状态决定何时恢复表单数据
    if (document.readyState === 'loading') {
        logger.debug('等待 DOM 加载完成...');
        document.addEventListener('DOMContentLoaded', () => {
            logger.debug('DOM 加载完成，准备恢复表单数据');
            setTimeout(() => restoreFormData(0, 5), 500);
        });
    } else {
        logger.debug('DOM 已经加载，直接恢复表单数据');
        setTimeout(() => restoreFormData(0, 5), 500);
    }

    // 自动保存定时器
    let autoSaveTimer = null;
    const autoSave = () => {
        if (autoSaveTimer) {
            clearTimeout(autoSaveTimer);
        }
        autoSaveTimer = setTimeout(saveFormData, 1000);
    };

    // 监听表单变化和页面卸载
    document.addEventListener('input', autoSave);
    document.addEventListener('change', autoSave);
    window.addEventListener('beforeunload', () => {
        logger.debug('页面即将卸载，保存表单数据');
        saveFormData();
    });
}

// 启动扩展
initializeExtension();